package com.zhdl.modules.autopick.service.impl;

import com.zhdl.modules.autopick.service.CmdHandleService;
import com.zhdl.network.service.MotorEasternService;
import com.zhdl.network.service.MotorService;
import com.zhdl.network.service.PcbService;
import com.zhdl.network.service.RobotArmService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class CmdHandleServiceImpl implements CmdHandleService {

    @Autowired
    private MotorService motorService;

    @Autowired
    private MotorEasternService motorEasternService;

    @Autowired
    private RobotArmService robotArmService;

    @Autowired
    private PcbService pcbService;


    /**
     * 机器人-测试 发送M信号
     *
     * @param address
     * @param open
     */
    @Override
    public void robotSendM(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
        log.info("发送地址为:" + address + "信号完成");
    }

    /**
     * 机器人-测试 清除M信号
     *
     * @param address
     */
    @Override
    public void robotReceiveM(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
        log.info("接收地址为:" + address + "信号完成");
    }

    /**
     * 机器人-初始化
     */
    @Override
    public void robotInit() {
        log.info("调取机器人指令-");
        robotArmService.getRobotStatus();
    }

    /**
     * 机器人-回原点信号 -M12
     */
    @Override
    public void robotM12(int address, boolean open) {
        log.info("调取机器人指令-回原点");
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-销毁信号 -M信号
     */
    @Override
    public void robotM11(int address, boolean open) {
        log.info("调取机器人指令-放料信号");
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-抓料信号 -M10
     */
    @Override
    public void robotM10(int address, boolean open) {
        log.info("调取机器人指令-抓料信号");
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-回原点完成 -M22
     *
     * @param address 地址
     */
    @Override
    public void robotM22(int address) {
        robotArmService.readWitchStatus(address);
        log.info("调取机器人指令-回原点完成");
    }

    /**
     * 机器人-放料完成 -M21
     */
    @Override
    public void robotM21(int address) {
        robotArmService.readWitchStatus(address);
        log.info("调取机器人指令-放料完成");
    }

    /**
     * 机器人-抓料完成 -M20
     */
    @Override
    public void robotM20(int address) {
        robotArmService.readWitchStatus(address);
        log.info("调取机器人指令-抓料完成");
    }

    /**
     * 机器人-等待气缸松开到位 -M110
     *
     * @param address
     * @param open
     */
    @Override
    public void robotM110(int address, boolean open) {
        log.info("调取机器人指令-等待气缸松开到位");
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-等待气缸抓紧到位 -M111
     *
     * @param address
     * @param open
     */
    @Override
    public void robotM111(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-等待气缸抓紧到位 -M112
     *
     * @param address
     * @param open
     */
    @Override
    public void robotM112(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-等待气缸抓紧到位 -M113
     *
     * @param address
     * @param open
     */
    @Override
    public void robotM113(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-等待抖料到位 -M114
     *
     * @param address
     * @param open
     */
    @Override
    public void robotM114(int address, boolean open) {
        robotArmService.writeWitchStatus(address, open);
    }

    /**
     * 机器人-通知松开开始 -M120
     *
     * @param address
     */
    @Override
    public void robotM120(int address) {
        robotArmService.readWitchStatus(address);
    }

    /**
     * 机器人-M信号
     *
     * @param address
     */
    @Override
    public void robotStatusM(int address) {
        robotArmService.readWitchStatus(address);
    }

    /**
     * 机器人-通知抓紧开始 -M121
     *
     * @param address
     */
    @Override
    public void robotM121(int address) {
        robotArmService.readWitchStatus(address);
    }

    /**
     * 机器人-通知气缸下移开始 -M122
     *
     * @param address
     */
    @Override
    public void robotM122(int address) {
        robotArmService.readWitchStatus(address);
    }

    /**
     * 机器人-通知气缸上回开始 -M123
     *
     * @param address
     */
    @Override
    public void robotM123(int address) {
        robotArmService.readWitchStatus(address);
    }


    /**
     * 机器人-通知抖料开始 -M124
     */
    @Override
    public void robotM124(int address) {
        robotArmService.readWitchStatus(address);
    }


    /**
     * 机器人-读取当前世界坐标
     */
    @Override
    public void robotStatusCoordinate() {
        //发送机器人指令，读取世界坐标
        robotArmService.getRobotStatus();
        log.info("调取机器人指令-读取世界坐标");
    }

    /**
     * 机器人 -- 上电上抬位置 820(55A0)-825
     *
     * @param currentLocation
     */
    @Override
    public void robotSetZLocation(int[] currentLocation) {
        log.info("调取机器人指令-设置上电上抬的坐标");
        robotArmService.initUpLocation(currentLocation);
    }

    /**
     * 设置 机器人抓取点 800(558C)-805
     */
    @Override
    public void pickLocation(int[] photoLocation) {
        log.info("调取机器人指令-设置抓取点位置");
        robotArmService.pickLocation(photoLocation);
    }

    /**
     * 设置 机器人抓取点上方 810(5596)-815
     */
    @Override
    public void pickUpLocation(int[] photoLocation) {
        log.info("调取机器人指令-设置抓取点正上方");
        robotArmService.pickUpLocation(photoLocation);
    }

    /**
     * 机器人-暂停 启动
     */
    @Override
    public void robotSetPause(boolean open) {
        robotArmService.robotWritePause(open);
        log.info("调取机器人指令-机器人暂停状态:" + open);
    }

    /**
     * 机器人-抓取
     */
    @Override
    public void robotPick() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-松开
     */
    @Override
    public void robotRelease() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-气缸下推
     */
    @Override
    public void robotAirDown() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-气缸上回
     */
    @Override
    public void robotAirUp() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-破袋
     */
    @Override
    public void robotCrackBag() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-抖动手臂
     */
    @Override
    public void robotShakeArm() {
        log.info("调取机器人指令-");
    }

    /**
     * 机器人-回原点
     */
    @Override
    public void robotGoHome() {
        log.info("调取机器人指令-");
    }

    /**
     * 电机-设置多端运动开始的段数
     *
     * @param step 开始段数
     */
    @Override
    public void motorStartStep(int step) {
        motorService.write06("1105", step);
    }

    /**
     * 电机-设置多端运动结束的段数
     *
     * @param step 结束段数
     */
    @Override
    public void motorEndStep(int step) {
        motorService.write06("1101", step);
    }

    /**
     * 电机-设置多端运动的速度
     *
     * @param speed 速度
     */
    @Override
    public void motorRunSpeed(int speed) {
        motorService.write06("110E", speed);
    }

    /**
     * 电机移动 - 10000个单位 为一圈
     *
     * @param moveDist 移动距离
     */
    @Override
    public void motorRun(String address, int moveDist) {
        motorService.setMoveDist(address, moveDist);
        log.info("调取电机指令-移动了" + moveDist);
    }

    /**
     * 电机移动 - 伺服使能 + 电机多端 运动
     */
    @Override
    public void motorReadyAndRun() {
        motorService.motorWriteRun();
        log.info("电机移动 - 伺服使能 + 电机多端 运动");
    }

    /**
     * 电机-初始化
     */
    @Override
    public void motorInit() {
        motorService.motorWriteZero();
        log.info("调取电机指令-电机初始化");
    }

    /**
     * 电机 - 读取电机当前状态 - 电机位置+偏移量
     */
    @Override
    public void motorStatus() {
        motorService.readOriginDistance();
        log.info("调取电机指令-获取了电机当前状态");
    }

    /**
     * 电机 - 读取电机当前状态 - 电机位置
     */
    @Override
    public void motorLocation() {
        motorService.motorReadLocation();
        log.info("调取电机指令-获取了电机当前位置");
    }

    /**
     * 电机 - 读取电机当前状态 - 是否到达远点
     */
    @Override
    public void motorArriveZero() {
        motorService.motorReadArriveZero();
        log.info("调取电机指令-获取了电机是否到原点了");
    }


    /**
     * 电机-使能
     */
    @Override
    public void motorReady() {
        motorService.motorWriteReady();
        log.info("调取电机指令-使能完成");
    }

    /**
     * 电机-停止运动
     */
    @Override
    public void motorStop() {
        motorService.motorWriteStop();
        log.info("调取电机指令-停止了");
    }

    /**
     * IO-抬起杆 --电磁阀
     */
    @Override
    public void motorUpPole() {
        log.info("调取IO指令-");
    }

    /**
     * IO-放下杆  --电磁阀
     */
    @Override
    public void motorDownPole() {
        log.info("调取IO指令-");
    }

    /**
     * IO-打开漏斗  --电磁阀
     */
    @Override
    public void motorOpenFunnel() {
        pcbService.ioWriteDoubleCoilSignal(8, true);
        log.info("调取IO指令-");
    }

    /**
     * IO-关闭漏斗 --电磁阀
     */
    @Override
    public void motorCloseFunnel() {
        pcbService.ioWriteDoubleCoilSignal(9, false);
        log.info("调取IO指令-");
    }

    /**
     * 电机-回到原点
     */
    @Override
    public void motorGoHome() {
        motorService.motorWriteZero();
        log.info("调取电机指令-回到原点");
    }

    /**
     * pcb-读取信息
     */
    @Override
    public void pcbReadInfo() {
        //pcbService.pcbReadInfo(2);
        pcbService.ioReadCoilSignal();
        pcbService.ioReadDiscreteSignal();
        log.info("调取pcb指令-读取什么东西");
    }

    /**
     * pcb-写入信息
     */
    @Override
    public void pcbWriteInfo(int address, String open) {
        pcbService.pcbWriteInfo(address, open);
        //pcbService.ioWriteCoilSignal(address, open);
        log.info("调取pcb指令-写入什么东西");
    }

    /**
     * io-写入单线圈
     */
    @Override
    public void ioWriteCoil(int address, String open) {
        pcbService.ioWriteCoilSignal(address, open);
        log.info("调取pcb指令-写入什么东西");
    }

    /**
     * io-写入双线圈
     */
    @Override
    public void ioWriteDoubleCoil(int address, boolean open) {
        pcbService.ioWriteDoubleCoilSignal(address, open);
        log.info("调取pcb指令-写入什么东西");
    }

    /**
     * 东区电机-电机找原点
     */
    @Override
    public void motorEasternInit() {
        //电机找原点
        motorEasternService.motorGoHome_1("01");
        log.info("东区电机-正在找原点");
    }

    /**
     * 东区电机-电机运动
     */
    @Override
    public void motorEasternRun(Integer destinationValue, Integer tSpeedValue) {
        //电机开始运动
        boolean status = motorEasternService.ctrlMotorMove_1("01", destinationValue, tSpeedValue);
        log.info("东区电机-开始运动，运动了" + destinationValue + "脉冲，速度为:" + tSpeedValue + "完成状态" + status);
    }

    /**
     * 东区电机-电机停止
     */
    @Override
    public void motorEasternStop() {
        //电机停止运动
        boolean status = motorEasternService.ctrlMotorStop();
        log.info("东区电机-停止运动，指令发送状态：" + status);
    }

    /**
     * 东区电机-获取电机当前状态
     */
    @Override
    public void motorEasternStatus() {
        //电机获取当前状态
        motorEasternService.getMotorStatus("01");
        log.info("正在读取电机当前状态");
    }

    /*
     * -------------------------除渣电机指令--------------------
     */

    /**
     * 除渣电机-设置多端运动开始的段数
     *
     * @param step 开始段数
     */
    @Override
    public void motorSlagStartStep(String slaveStationId, int step) {
        motorService.writeSlag06(slaveStationId, "1105", step);
    }

    /**
     * 除渣电机-设置多端运动结束的段数
     *
     * @param step 结束段数
     */
    @Override
    public void motorSlagEndStep(String slaveStationId, int step) {
        motorService.writeSlag06(slaveStationId, "1101", step);
    }

    /**
     * 除渣电机-设置多端运动的速度
     *
     * @param speed 速度
     */
    @Override
    public void motorSlagRunSpeed(String slaveStationId, int speed) {
        motorService.writeSlag06(slaveStationId, "110E", speed);
        log.info("除渣电机-调取电机指令，设置多端");
    }

    /**
     * 电机移动 - 10000个单位 为一圈
     *
     * @param moveDist 移动距离
     */
    @Override
    public void motorSlagRun(String slaveStationId, String address, int moveDist) {
        motorService.setSlagMoveDist(slaveStationId, address, moveDist);
        log.info("除渣电机-调取电机指令-移动了" + moveDist);
    }

    /**
     * 电机移动 - 伺服使能 + 电机多端 运动
     */
    @Override
    public void motorSlagReadyAndRun(String slaveStationId) {
        motorService.motorWriteSlagRun(slaveStationId);
        log.info("除渣电机-电机移动 - 伺服使能 + 电机多端 运动");
    }

    /**
     * 电机-初始化
     */
    @Override
    public void motorSlagInit(String slaveStationId) {
        motorService.motorWriteSlagZero(slaveStationId);
        log.info("除渣电机-调取电机指令-电机初始化");
    }

    /**
     * 电机 - 读取电机当前状态 - 电机位置+偏移量
     */
    @Override
    public void motorSlagStatus(String slaveStationId) {
        motorService.readSlagOriginDistance(slaveStationId);
        log.info("除渣电机-调取电机指令-获取了电机当前状态");
    }

    /**
     * 电机 - 读取电机当前状态 - 电机位置
     */
    @Override
    public void motorSlagLocation(String slaveStationId, String address) {
        motorService.motorReadSlagLocation(slaveStationId, address);
        log.info("除渣电机-调取电机指令-获取了电机当前位置");
    }


    /**
     * 电机-使能
     */
    @Override
    public void motorSlagReady(String slaveStationId) {
        motorService.motorWriteSlagReady(slaveStationId);
        log.info("除渣电机-调取电机指令-使能完成");
    }

    /**
     * 电机-停止运动
     */
    @Override
    public void motorSlagStop(String slaveStationId) {
        motorService.motorWriteSlagStop(slaveStationId);
        log.info("除渣电机-调取电机指令-停止了");
    }


}